R Notebook

This file will take you through recreating the figures presented in the manuscript. Note that some of the figures went through additional edits in Illustrator for additional labelling!

Preparation

Load packages

library(dplyr)

Warning: package ‘dplyr’ was built under R version 4.2.3

Attaching package: ‘dplyr’

The following objects are masked from ‘package:stats’:

    filter, lag

The following objects are masked from ‘package:base’:

    intersect, setdiff, setequal, union

library(ggplot2)

Warning: package ‘ggplot2’ was built under R version 4.2.3

library(forcats)
library(here)

here() starts at /Users/avrilwang/Desktop/Project-Plasmodium

library(deSolve)

Warning: package ‘deSolve’ was built under R version 4.2.3

library(crone)
library(optimParallel)

Loading required package: parallel

library(doParallel)

Loading required package: foreach
Loading required package: iterators

library(doRNG)

Loading required package: rngtools

library(arrow)

Some features are not enabled in this build of Arrow. Run `arrow_info()` for more information.
The repository you retrieved Arrow from did not include all of Arrow's features.
You can install a fully-featured version by running:
`install.packages('arrow', repos = 'https://apache.r-universe.dev')`.

Attaching package: ‘arrow’

The following object is masked from ‘package:utils’:

    timestamp

library(stringr)

Warning: package ‘stringr’ was built under R version 4.2.3

library(parallel)
library(ggpubr)
library(scales)

Warning: package ‘scales’ was built under R version 4.2.3

library(bayestestR)
library(purrr)

Attaching package: ‘purrr’

The following object is masked from ‘package:scales’:

    discard

The following objects are masked from ‘package:foreach’:

    accumulate, when

library(tidyr)
library(splines2)
library(splancs)

Loading required package: sp

Spatial Point Pattern Analysis Code in S-Plus
 
 Version 2 - Spatial and Space-Time analysis


Attaching package: ‘splancs’

The following object is masked from ‘package:tidyr’:

    tribble

The following object is masked from ‘package:dplyr’:

    tribble

load variables

parameters_tsukushi <- c(R1 = 8.89*10^6, 
                lambda = 3.7*10^5,
                mu = 0.025, 
                p = 8*10^-6, 
                alpha = 1, 
                alphag = 2, 
                beta = 5.721, 
                mum = 48, 
                mug = 4, 
                I0 = 43.85965, 
                Ig0 = 0, 
                a = 150, 
                b = 100, 
                sp = 1,
                psin = 16.69234,
                psiw = 0.8431785,
                phin = 0.03520591, 
                phiw = 550.842,
                iota = 2.18*(10^6),
                rho = 0.2627156)

# import in data files
ez_label <- read.csv(here("code_repository/data/ez_label.csv")) ## labelling schene
si_opt.df <- read.csv(here("code_repository/data/si_opt.csv")) ## optimized parameter + fitness list
si_dyn.df <- read_parquet(here("code_repository/data/si_dyn.parquet")) ## dynamics of single cue models
si_rn.df <-  read_parquet(here("code_repository/data/si_rn.parquet")) ## reaction norms of single cue models
si_rug.df <- read_parquet(here("code_repository/data/si_rug.parquet")) ## data for rug plots
mc_all_fitness.df <- read_parquet(here("code_repository/data/mc_all_fitness.parquet")) ## fitness values for mc when all parameters are varying
mc_single_fitness.df <- read_parquet(here("code_repository/data/mc_single_fitness.parquet")) ## fitness values for mc when only one parameter is varying
dual_cue_f_lc.df <- read.csv(here("code_repository/data/dual_cue_fitness_local.csv")) ## optimized dual cue strategy using L-BFGS-B
dual_cue_f_glb.df <- read.csv(here("code_repository/data/dual_cue_fitness_global.csv")) ## optimized dual cue strategy using DEoptim + L-BFG
dual_cue_f_final.df <- read.csv(here("code_repository/data/dual_cue_fitness_final.csv")) ## final dataframe containing strategy that produced highest fitness (dual cue models)
dual_selected_cr.df <- read_parquet(here("code_repository/data/dual_selected_cr.parquet")) ## cr dynamics of selected models
cue_range_si_alt.df <- read.csv(here("code_repository/data/cue_range_si_alt.csv")) ## cue ranges for dual cue models
dual_cue_dyn.df <- read_parquet(here("code_repository/data/dual_cue_dyn.parquet")) ## dynamics of dual cue models
exp_ss.df <- read.csv(here("code_repository/data/experimental_data.csv")) ## cleaned experimental records of P. chabaudi infection
posterior.df <- read.csv(here("code_repository/data/posterior.csv")) ## posterior distribution of different parameter values
si_dyn_30.df <- read_parquet(here("code_repository/data/si_dyn_30.parquet")) ## single cue dynamics data (30 days)
dual_cue_dyn_30.df <- read_parquet(here("code_repository/data/dual_cue_dyn_30.parquet")) ## dual cue dynamics (30 days)
mc_single_dyn_cr_join.df_pr <- read_parquet(here("code_repository/data/mc_sinle_dyn_cr_join.parquet")) ## mc dynamics (single parameter variation) with only cr along with determinstic model cr
mc_single_dyn_cr.sumre <- read.csv(here("code_repository/data/mc_single_dyn_cr_sum.csv")) ## mc dynamics (single parameter) cr summary

## validation data (comparing fitness to random spline)
validation.ls <- list.files(here("code_repository/data/si_validation/"), full.names = T)
validation.df <- do.call(rbind, lapply(validation.ls, read.csv))

# import in code
source(here("code_repository/functions/chabaudi_si_clean.R"))
source(here("code_repository/functions/par_to_df.R"))
source(here("code_repository/functions/chabaudi_si_clean_high.R"))
source(here("code_repository/functions/par_to_hm.R"))
source(here("code_repository/functions/par_to_hm_te.R"))
source(here("code_repository/functions/chabaudi_si_static.R"))

# color codes
orange <- "#fc8d59"
blue <- "#4575b4"

#=================================# # Cue perception mediates fitness #=================================# #———— A. conversion rate dynamics and fitness values ————# ## function for dynamics generation

# function for getting single cue infection dynamics
get_si_dyn <- function(df){
  ## processing model input
  par <- c(df$var1, df$var2, df$var3, df$var4) ## parameters
  cue <- df$cue ## cue choice
  log <- ifelse(df$log=="log", "log10", "none") ## log or not
  cue_range <- seq(df$low, df$high, by = df$by) ## cue range
  id <- df$id ## id
  
  ## get dynamics data
  dyn <- chabaudi_si_clean(
            parameters_cr = par, 
            parameters = parameters_tsukushi, 
            time_range = seq(0, 20, 0.001), 
            cue = cue, 
            cue_range = cue_range, 
            log_cue = log,
            immunity = "tsukushi",
            solver = "vode",
            dyn = TRUE)
  
  # append id
  dyn2 <- cbind(dyn, id = rep(id, nrow(dyn)))
  
  # return results
 return(dyn2)
}

run function to generate data

## split si_opt into list
si_opt.ls <- split(si_opt.df, seq(nrow(si_opt.df)))

## get dynamics
si_dyn <- mclapply(si_opt.ls, get_si_dyn, mc.cores = 8)

## combine the dynamics file
si_dyn.df <- do.call(rbind, si_dyn)

## save
# write_parquet(si_dyn.df, here("code_repository/data/si_dyn.parquet"))

get 30 day simulation data (not used for fitness but for plotting purposes)

## get dynamics
si_opt.ls2 <- split(si_opt.df %>% filter(cue != "t"), seq(nrow(si_opt.df%>% filter(cue != "t"))))
si_dyn_30 <- mclapply(si_opt.ls2, get_si_dyn, mc.cores = 8)

## combine the dynamics file
si_dyn_30.df <- do.call(rbind, si_dyn_30)
si_dyn_30.df %>% group_by(id) %>% summarise(max_time = max(time))

## save
write_parquet(si_dyn_30.df, here("code_repository/data/si_dyn_30.parquet"))

process data to isolate conversion rate and pair them with fitness

## keep only conversion rate from dynamics
si_dyn_cr.df <- si_dyn.df %>% filter(variable == "cr")

## left join with fitness values
si_dyn_cr_fitness.df <- si_dyn_cr.df %>% 
  left_join(si_opt.df, by = "id") 

## normalize fitness by dividing all values by the fitness values we get when cue = time
si_opt.df <- si_opt.df %>% 
  mutate(fitness_norm = fitness_20 / si_opt.df[si_opt.df$cue == "t",]$fitness_20)

plot

## fitness values ranked from high to low
fitness_rank.plt <- ggplot(si_opt.df, aes(x = fitness_norm, y = fct_reorder(long_label, fitness_20))) +
  geom_bar(stat = "identity", fill = "black") +
  labs(x = "Normalized fitness", y = "Cue") +
  theme_classic() +
  theme(plot.margin = margin(5.5, 0, 5.5, 5.5, "pt"))

## conversion rate dynamic ranked in the same order
fitness_cr.plt <- ggplot(si_dyn_cr_fitness.df, aes(x = time, y = fct_reorder(long_label, fitness_20), fill = value)) +
  geom_raster() +
  scale_fill_viridis_c() +
  labs(fill = "Transmission\ninvestment", x = "Time (days)") +
  xlim(1, 20) + # note that cr at day 0->1 is always 0 due to how the model is set up!
  theme_classic() +
  theme(axis.title.y=element_blank(),
        axis.text.y=element_blank(),  #remove y axis labels
        axis.ticks.y=element_blank()  #remove y axis ticks
        )

## plot together
fitness_rank_cr.plt <- ggarrange(fitness_rank.plt, fitness_cr.plt, widths = c(1.2, 1), align = "h", common.legend = T,
                                 legend = "bottom")

Warning: Removed 11022 rows containing missing values or values outside the scale range
(`geom_raster()`).
Warning: Removed 11022 rows containing missing values or values outside the scale range
(`geom_raster()`).

#———— B. Reaction norms ————# ## function to obtain the cue values sensed by parasites from dynamics datas

get_rug <- function(df){
  ## process cue
  cue <- unique(df$cue)
  
  ## if cue contains "+", we need to first split them up and add them into the final dataframe
   if(stringr::str_detect(cue, "\\+")){
    cue_split <- stringr::str_split(string = cue, pattern = "\\+", simplify = T)
    ## get the two cues 
    cue_temp_1 <- cue_split[[1]]
    cue_temp_2 <- cue_split[[2]]
    ## filter dyn
    rug <- df %>% 
      filter(variable == cue_temp_1 | variable == cue_temp_2) %>% 
      dplyr::group_by(time) %>% 
      dplyr::mutate(sum = sum(value, na.rm = T)) %>% 
      select(time, value = sum, id)
  }
  
  # for cue with no addition, it is simply filtering for the values and returning it
  if(stringr::str_detect(cue, "\\+", negate = T)){
    rug <- df %>% 
      dplyr::filter(variable == cue) %>% 
      dplyr::select(time, value, id)}
  
  return(rug)
}

run function to obtain cue values

# join dynamics data with cue information
si_dyn_cue.df <- left_join(si_dyn.df, si_opt.df, by = "id")

# split based on individual labels
si_dyn_cue.ls <- si_dyn_cue.df %>% group_split(id)

# run function to get rug
si_rug <- mclapply(si_dyn_cue.ls, get_rug, mc.cores = 6)

# combine and save
si_rug.df <- do.call(rbind, si_rug)
write_parquet(si_rug.df, here("code_repository/data/si_rug.parquet"))

function to obtain reaction norm

get_si_rn <- function(df){
  ## read in the parameter sets
  par <- c(df$var1, df$var2, df$var3, df$var4)
  ## get cue range
  cue_range <- seq(df$low, df$high, by = df$by)
  ## nested function to convert parameter set into basis spline function
  rn <- par_to_df(par = par, cue_range = cue_range)
  
  # if parasite is sensing logged cue, we have to exponentiate it back so they are on the same scale! 
  rn2 <- rn
  if(stringr::str_detect(df$log, "log")){rn2$cue_range <- 10^(rn2$cue_range)}

  # append label to reaction norm, dyn, and rug
  rn2 <- data.frame(rn2, id = df$id)
  
  return(rn2)
}

run function to get reaction norms

# split dataframe of optimized rcues
si_opt.ls <- split(si_opt.df, seq(nrow(si_opt.df)))

# run function
si_rn <- lapply(si_opt.ls, get_si_rn)

# bind together
si_rn.df <- do.call(rbind, si_rn)
write_parquet(si_rn.df, here("code_repository/data/si_rn.parquet"))

preparing the dataset for plotting reaction norms and rugs

## we are only plotting relevent ranges of the reaction norm, meaning that these are the cue values actually "sensed" by the parasites in an infection. We can use the rug dataframe to get a rough estimate of that
si_rug_lim.df <- si_rug.df %>% 
  group_by(id)%>% 
  summarise(min_temp = min(value, na.rm = T)*0.9,
         max_temp = max(value, na.rm = T)*1.1) %>% ## calculate min and max for each cue
  left_join(si_opt.df, by = "id") %>% ## join with si_opt so we can get the cmmon cue
  ungroup() %>% 
  group_by(cue) %>% 
  summarise(min = min(min_temp), max = max(max_temp)) 

## process reaction norm data to restrict range and get label
si_rn.df_p <- si_rn.df %>% 
  left_join(select(si_opt.df, id, cue, log), by = "id") %>% ## get cue and log status from si_opt.df
  left_join(si_rug_lim.df, by = "cue") %>% ## via cue, get ranges we want to limit the rn to
  filter(cue_range <= max & cue_range >= min) %>% ## keep only cue values within range
  left_join(select(ez_label, id, cue_label), by = "id") # get labels


## refactor to reorder the order at which the cues are presented
si_rn.df_p$cue_label <- factor(si_rn.df_p$cue_label, 
                              levels = c("Asexual iRBC", "Sexual iRBC", "Total iRBC", "Gametocyte", "RBC"))

## split rug labels by none logged and logged
si_rug_cue.df <- si_rug.df %>% 
  distinct(id, value) %>% ## cut down on number of datapoints. For each id, keep only distinct points
  left_join(select(si_opt.df, id, cue, log), by = "id") %>% ## get cue and log status from si_opt.df
  left_join(select(ez_label, id, cue_label), by = "id") ## get cue label for plotting

## refactor rug
si_rug_cue.df$cue_label <- factor(si_rug_cue.df$cue_label, 
                              levels = c("Asexual iRBC", "Sexual iRBC", "Total iRBC", "Gametocyte", "RBC"))

### split
si_rug_cue.df_none <- si_rug_cue.df %>% filter(log == "none")
si_rug_cue.df_log <- si_rug_cue.df %>% filter(log == "log")

plot reaction norms and associated rug plots

#———— Plotting fitness, dynamics, and rn together ————#

ggarrange(fitness_rank_cr.plt, fitness_rn.plt, widths = c(2.7, 1), align = "h", ncol = 2, labels = c("A", "B"))

Warning: Graphs cannot be horizontally aligned unless the axis parameter is set. Placing graphs unaligned.

#=================================# # Dual cue fitness main figure #=================================# #————Relative ranking of dual cue vs single cue fitness———–# ## Prepare dual cue dataset

## For the dual cue models, we optimized each cue combinations in 2 ways, one with L-BFGS-B with 0.5X9 starting point and another with DEoptim + L-FGBS-B. For each cue combination, we are going to pick the strategy that gave us the higher fitness
dual_cue_f_final.df <- dual_cue_f_glb.df %>% 
  select(id, id_b, label, label_b, fitness_glb = fitness, 
         par1_glb = par1, par2_glb = par2, par3_glb = par3, par4_glb = par4, par5_glb = par5, par6_glb = par6,
         par7_glb = par7, par8_glb = par8, par9_glb = par9) %>% 
  left_join(
    select(dual_cue_f_lc.df,
         id, id_b, fitness_lc = fitness, 
         par1_lc = par1, par2_lc = par2, par3_lc = par3, par4_lc = par4, par5_lc = par5, par6_lc = par6,
         par7_lc = par7, par8_lc = par8, par9_lc = par9), by = c("id", "id_b")
  ) %>% ## rename columns and join global and local optimization fitness dataframes
  mutate(
    fitness = ifelse(fitness_glb > fitness_lc, fitness_glb, fitness_lc),
    par1 = ifelse(fitness_glb > fitness_lc, par1_glb, par1_lc),
    par2 = ifelse(fitness_glb > fitness_lc, par2_glb, par2_lc),
    par3 = ifelse(fitness_glb > fitness_lc, par3_glb, par3_lc),
    par4 = ifelse(fitness_glb > fitness_lc, par4_glb, par4_lc),
    par5 = ifelse(fitness_glb > fitness_lc, par5_glb, par5_lc),
    par6 = ifelse(fitness_glb > fitness_lc, par6_glb, par6_lc),
    par7 = ifelse(fitness_glb > fitness_lc, par7_glb, par7_lc),
    par8 = ifelse(fitness_glb > fitness_lc, par8_glb, par8_lc),
    par9 = ifelse(fitness_glb > fitness_lc, par9_glb, par9_lc)
  ) ## the columns are assigned based on which strategy produced the highest fitness

## write csv
write.csv(dual_cue_f_final.df, here("code_repository/data/dual_cue_fitness_final.csv"))

Combine single cue and dual cue dataset

plot fitness rank

dual_fitness.pl <- ggplot(dual_si_fitness.df) +
  geom_segment(aes(y = fct_reorder(label_comb, fitness_dual_norm), yend = fct_reorder(label_comb, fitness_dual), x = fitness_dual_norm, xend = fitness_si_final)) + ## line segment connecting the cue values
  geom_point(aes(y = fct_reorder(label_comb, fitness_dual), x = fitness_dual_norm, color = "Dual cue", shape = "Dual cue"),
             size = 2.5) + ## dual cue fitness
  geom_point(aes(y = fct_reorder(label_comb, fitness_dual_norm), x = fitness_si_final, color = "Best single cue", shape = "Best single cue"), size = 2.5) + ## best single cue fitness
  scale_color_manual(values=c("#fc8d59", "#4575b4")) +
  labs(x = "Normalized fitness", y = "Dual cue combinations", colour = "Legend", shape = "Legend") +
  theme_classic() +
  theme(legend.position = "top")

#————Time series conversion rate of dual cue models———–# Note that our dual cue models take 9 parameters. To ensure that any difference between dual and single cue models is due to the inclusion of additional cues and NOT higher spline flexibility,we performed L-BFGS-B (local) optimization of single cue models with df = 9 to control for the spline flexibility.

dynamics simulation of high parameter cues

## best dual cue model: I log and R log
Rlog_Ilog.cr <- chabaudi_si_clean(
  parameters_cr = c(4.446192033,    10.97518275,    1.38762817, 23.3059254, -3.452052371,   -18.0070692,    39.66614226,    -3.545193141,   18.78350799),
  immunity = "tsukushi",
  parameters = parameters_tsukushi,
  time_range = seq(0, 20, by = 1e-3),
  cue_range =  seq(6, 7, by = 1/500),
  cue_range_b = seq(0, log10(6*(10^6)), by = (log10(6*(10^6)))/500),
  cue = "R",
  cue_b = "I",
  log_cue = "log10",
  log_cue_b = "log10",
  solver = "vode",
  dyn = T
)

plot

ggplot() +
  geom_line(data = dual_selected_cr.df, aes(color = label_new, x = time, y = value), size = 1) +
  geom_point(data = dual_selected_cr.df %>% filter(time%%1 == 0), aes(color = label_new, x = time, y = value, shape = label_new), size = 3) +
  labs(x = "Time (days)", y = "Conversion rate", color = "Cue(s)", shape = "Cue(s)") +
  xlim(0, 20) +
  scale_color_manual(values = c(orange,"#E1BE6A",blue ,"black")) +
  theme_classic() +
  theme(legend.position="right",
        plot.margin = margin(t = 40, r = 0, b = 0, l = 0, unit = "pt")) +
  guides(color = guide_legend(nrow = 4, byrow = TRUE))

Warning: Removed 3 rows containing missing values or values outside the scale range (`geom_line()`).
Warning: Removed 3 rows containing missing values or values outside the scale range (`geom_point()`).

#——– Reaction norm heatmap of R log10 + I log10 ————# # Process data

# make heatmap data.frame
Rlog_Ilog.hm <- par_to_hm_te(par = c(4.446192033,   10.97518275,    1.38762817, 23.3059254, -3.452052371,   -18.0070692,    39.66614226,    -3.545193141,   18.78350799),
             cue_range = seq(6, 7, length.out = 500),
             cue_range_b = seq(0,   6.77815125, length.out = 500))

# process dynamics
Rlog_Ilog.dyn <- Rlog_Ilog.cr %>% 
  tidyr::pivot_wider(names_from = variable, values_from = value) %>% 
  mutate(log_R = log10(R),
         log_I = log10(I))

plot

Rlog_Ilog_rn.pl <- ggplot() +
  geom_raster(data = Rlog_Ilog.hm, aes(x = cue_range_b, y = cue_range, fill = cr)) +
  scale_fill_viridis_c() +
  geom_path(data = Rlog_Ilog.dyn, aes(x = log_I, y = log_R), color = "white", arrow = arrow(angle = 30, length = unit(0.1, "inches"))) +
  geom_point(data = Rlog_Ilog.dyn %>% filter(row_number() %% 1000 == 1 & time <= 20), aes(x = log_I, y = log_R), color = "white") +
  xlim(0.99*min(hablar::s(Rlog_Ilog.dyn$log_I), na.rm = T), 1.01* max(hablar::s(Rlog_Ilog.dyn$log_I), na.rm = T)) +
  ylim(0.99*min(hablar::s(Rlog_Ilog.dyn$log_R), na.rm = T),1.01* max(hablar::s(Rlog_Ilog.dyn$log_R), na.rm = T)) +
  labs(y = "RBC log", x = "Asexual iRBC log", fill = "Transmission\ninvestment") +
  theme_classic() +
  theme(legend.position = "right")

#———– Plot together ————#

# assemble panel B and C
dual_main.BC <- ggarrange(dual_selected_cr.pl, Rlog_Ilog_rn.pl, align = "v", ncol = 1, labels = c("B", "C"))

Warning: Removed 3 rows containing missing values or values outside the scale range (`geom_line()`).
Warning: Removed 3 rows containing missing values or values outside the scale range (`geom_point()`).
Warning: Removed 219202 rows containing missing values or values outside the scale range
(`geom_raster()`).

# assemble panel A
ggarrange(dual_fitness.pl, dual_main.BC, ncol = 2, labels = c("A", ""), widths = c(1.1,1))
ggsave(here("code_repository/figures/dual_main_intermediate.tiff"), units = "px", width = 2250, height = 1400, scale = 1.3, dpi=300,  bg = "white")

#=================================# # Dual cue conversion rate supplementary figure (cr dynamics) #=================================# ## Function to simulate dual cue dynamics

dual_cue_dyn <- function(df){
  ## process cues
  cue <- df$cue
  cue_b <- df$cue_b
  
  ## process log
  log <- ifelse(str_detect(df$id, "log"), "log10", "none")
  log_b <- ifelse(str_detect(df$id_b, "log"), "log10", "none")
  
  # process cue_range. ensure that both cue ranges are of the same length
  cue_range <- seq(df$low, df$high, length.out = 500)
  cue_range_b <- seq(df$low_b, df$high_b, length.out = 500)
  
  # get parameter set
  par <- c(df$par1, df$par2, df$par3, df$par4, df$par5, df$par6, df$par7, df$par8, df$par9)
  
  # simulate dynamics
  dyn <- chabaudi_si_clean(
    parameters_cr = par,
    immunity = "tsukushi",
    parameters = parameters_tsukushi,
    time_range = seq(0, 20, 0.01),
    cue = cue,
    cue_b = cue_b,
    cue_range = cue_range,
    cue_range_b = cue_range_b,
    log_cue = log,
    log_cue_b = log_b,
    solver = "vode",
    gam = "te",
    dyn = T)
  
  # return 
  dyn2 <- cbind(id = df$id, id_b = df$id_b, 
                label = df$label, label_b = df$label_b,
                cue = cue, cue_b = cue_b, dyn)
  
  write_parquet(dyn2, here(paste0("code_repository/data/dual_cue_dyn/", df$id, "_", df$id_b, ".parquet")))
}

Get dynamics of dual cue models

## For the dual cue fitness dataframe, add the cue range for each individual cue
dual_cue_f_final.df_p <- dual_cue_f_final.df %>% 
  left_join(select(cue_range_si_alt.df, id, cue, low, high), by = "id") %>% 
  left_join(select(cue_range_si_alt.df, id_b = id, cue_b = cue, low_b = low, high_b = high), by = "id_b")

## Split dataframes
dual_cue_f_final.ls <- split(dual_cue_f_final.df_p, seq(nrow(dual_cue_f_final.df_p)))

## Run function
mclapply(dual_cue_f_final.ls, dual_cue_dyn, mc.cores = 6)

## Concat all files
dual_cue_dyn.ls <- list.files(path = here("code_repository/data/dual_cue_dyn"), pattern = "*.parquet", full.names = T)
dual_cue_dyn.df <- do.call(rbind, lapply(dual_cue_dyn.ls, read_parquet))
write_parquet(dual_cue_dyn.df, here("code_repository/data/dual_cue_dyn.parquet"))

get 30 days dynamic (for plotting purposes)

## Run function
mclapply(dual_cue_f_final.ls, dual_cue_dyn, mc.cores = 6)

## Concat all files
dual_cue_dyn_30.ls <- list.files(path = here("code_repository/data/dual_cue_dyn_30"), pattern = "*.parquet", full.names = T)
dual_cue_dyn_30.df <- do.call(rbind, lapply(dual_cue_dyn_30.ls, read_parquet))
write_parquet(dual_cue_dyn_30.df, here("code_repository/data/dual_cue_dyn_30.parquet"))

Preparing dataset for plotting

Plot

ggplot(data = dual_cue_cr.df, aes(x = time, y = fct_reorder(label_comb, fitness), fill = value)) +
  geom_raster() +
  scale_fill_viridis_c() +
  xlim(1, 20) +
  labs(x = "Time (days)", y = "Dual cue combination", fill = "Transmission\ninvestment") +
  theme_classic()

Warning: Removed 4080 rows containing missing values or values outside the scale range (`geom_raster()`).

ggsave(here("code_repository/figures/dual_cue_cr.tiff"), units = "px", width = 2000, height = 1500, dpi=300,  bg = "white")

Warning: Removed 4080 rows containing missing values or values outside the scale range (`geom_raster()`).

#=================================# # Cumulative transmission plot of dual and single cue models #=================================# # get cumulative tau

# process 
I_high.taucum <- I_high.cr %>% filter(variable == "tau_cum") %>% mutate(label_new = "I log (df=9)") %>% select(-variable)

R_high.taucum <- R_high.cr %>% filter(variable == "tau_cum") %>% mutate(label_new = "R log (df=9)") %>% select(-variable)

time_high.taucum <- time_high.cr %>% filter(variable == "tau_cum") %>% mutate(label_new = "Time (df=9)") %>% select(-variable)

Rlog_Ilog.taucum <- Rlog_Ilog.cr %>% filter(variable == "tau_cum") %>% mutate(label_new = "R log & I log\n(df=9)") %>% select(-variable)

plot

#=================================# # Experimental disease maps of P. chabaudi #=================================# ## Import in data

# import in https://academic.oup.com/emph/article/2018/1/127/5045871?login=true
## (2018 published in EMPH)
emph_2018 <- readxl::read_xls(here("code_repository/experimental_data/Huijben_2018_EMPH.xls"), sheet = 1)

# import in https://onlinelibrary.wiley.com/doi/10.1111/j.1558-5646.2010.01068.x
## (2010 published in Evolution)
evo_2010 <- readxl::read_xls(here("code_repository/experimental_data/Huijben_2010_evolution.xls"), sheet = 1)

# import in https://journals.plos.org/plospathogens/article?id=10.1371/journal.ppat.1003578#:~:text=The%20philosophy%20is%20that%20aggressive,longer%20feel%20sick%20%5B13%5D.
## (2013 in PLoS pathogen)
plos_2013_1 <- readxl::read_xlsx(here("code_repository/experimental_data/Huijben_2013_PLoS.xlsx"), sheet = 2)

plos_2013_2 <- readxl::read_xlsx(here("code_repository/experimental_data/Huijben_2013_PLoS.xlsx"), sheet = 3)

# import in https://onlinelibrary.wiley.com/doi/10.1111/j.1420-9101.2011.02369.x
## (2011 in Journal of Evolutionary Biology)
eseb_2011 <- readxl::read_xls(here("code_repository/experimental_data/Huijben_2011_eseb.xls"), sheet = 1)

# import in https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3939351/
## (2011 in Journal of American naturalist). Note private dataset so not provided in the supplementary!
amna_2011 <- readxl::read_xls(here("experimental_data/Pollitt_2011_naturalist.xls"), sheet = 1)

Clean data

## for EMPH 2018 study, include only infection series without drugs were R-inoculum is administered by itself, which includes 6, 7, 8, 9, 10. Box 6 has a starting inoculum number of 10^6, which is most similar to other studies. Filtering between day 3-21 because those are the days where we have single day data.
emph_2018_ss.df <- emph_2018 %>% 
  filter(Box %in% seq(6, 10) &
         dplyr::between(Day, 3, 21)) %>% 
  mutate(dose = case_when(
    Box == 6 ~ 10^6,
    Box == 7 ~ 10^5,
    Box == 8 ~ 10^3,
    Box == 9 | Box == 10 ~ 10^1
  )) %>% 
  mutate(strain = "As6p",
         study = "emph2018",
         study_strain = paste0(strain, study),
         id = paste0(study, strain, Box, Mouse, 1),
         RBC = RBC * (10^6)) %>%
  select(day = Day,
         mouse = Mouse, 
         RBC, 
         asex = Rasex,
         gam = Rgam,
         dose,
         strain,
         study,
         study_strain,
         id)

## for 2011 eseb, only day 3-17 data are analyzed because those are the days where gametocyte data are available
eseb_2011_ss.df <- eseb_2011 %>% 
  filter(Clones == "R" & between(Day, 3, 17) &
           Drugs == "N") %>% 
  mutate(dose = 10^6,
         strain = "As8p",
         study = "eseb2011",
         study_strain = paste0(strain, study),
         RBC = RBC*(10^6),
         id = paste0(study, strain, Box, Mouse, 2)) %>% 
  select(day = Day,
         mouse = Mouse,
         RBC,
         asex = R.asex,
         gam = R.gam,
         dose,
         strain,
         study,
         study_strain,
         id)

## for evolution_2010, single infection data for both resistant and susceptible clones are available without drug treatment
evolution_2010_ss.df <- evo_2010 %>% 
  filter(Clone == "R" | Clone == "S") %>%
  filter(between(Day, 3, 21) &
           Drugs == "nodrugs") %>% 
  mutate(asex = R.asex + S.asex,
         gam = R.gam + S.gam,
         dose = 10^6,
         RBC = RBC*(10^6),
         study = "evol2011",
         strain = ifelse(Clone == "R", "As12", "AJ51"),
         study_strain = paste0(strain, "_", study),
         id = paste0(study, strain, Box, Mouse, 3)) %>% 
  select(day = Day,
         mouse = Mouse,
         RBC,
         asex,
         gam,
         dose,
         strain,
         study,
         study_strain,
         id)

## for amnat 2011, get single infection data. Filter out any mice that have missing data. Set negative asexuasl data ot 0
amna_2011_ss.df <-  amna_2011 %>% 
  filter(treat %in% c("AJ", "AS", "ER", "CR", "CW", "DK")) %>% 
  mutate(asex = tot.para - tot.gcyte,
         gam = tot.gcyte,
         dose = 10^6,
         study = "amna_2011",
         RBC = rbc/(10^6),
         study_strain = paste0(treat, "_", study),
         id = paste0(study, treat, div, mouse, 4)) %>% 
  mutate(asex = ifelse(asex < 0, 0, asex)) # sometimes total parasite is less than gametocyte so need to correct for this

### check for NA by groups
amna_na.id <- amna_2011_ss.df %>% 
  filter_at(vars(asex, gam, RBC), all_vars(is.na(.))) %>% 
  distinct(id) %>% 
  select(id)

amna_2011_ss.df2 <- amna_2011_ss.df %>% 
  filter(!(id %in% amna_na.id$id)) %>% 
  select(day,
         mouse,
         RBC,
         asex,
         gam,
         dose,
         strain = treat,
         study,
         study_strain,
         id)

## rbind
exp_ss.df <- rbind(emph_2018_ss.df, eseb_2011_ss.df, evolution_2010_ss.df, amna_2011_ss.df2)

## write
write.csv(exp_ss.df, here("code_repository/data/experimental_data.csv"))

Prepare dataset for plotting

names(exp_ss.df) <- c("X", "Day", "Mouse", "RBC", "iRBC", "Gametocyte", "Dose", "Strain", "Study", "Study_strain", "id")

## prepare a list of variable combinations we want to plot
exp_var.comb <- tidyr::expand_grid(x = c("RBC", "iRBC", "Gametocyte"),
                   y = c("RBC", "iRBC", "Gametocyte")) %>% ## get all pairwise combinations of variables
  filter(x != y) %>% ## remove incidences where the 2 variables are the same
  mutate(tmp = paste0(pmin(x, y), pmax(x, y))) %>% ## eliminate same variable but different order
  slice_head(n = 1, by = tmp) %>% 
  select(-tmp) 

List-wise plotting

## x and y axis are not logged!
exp_xy.pl_ls <- map2(exp_var.comb$x, exp_var.comb$y, ~ {
  x_col <- .x
  y_col <- .y
  
  ggplot(exp_ss.df, aes_string(x = x_col, y = y_col)) +
        geom_path(aes(colour = Day, group = id), arrow = arrow(type = "closed", angle = 10, length = unit(0, "inches"))) +
        theme_classic() + 
        scale_color_viridis_c(option = "A", limits = c(3, 21)) +
        labs(color = "Days post-infection")  +
        scale_y_continuous(labels = function(x) format(x, scientific = TRUE)) +
        scale_x_continuous(labels = label_scientific(digits = 1))
}
)

## x-axis is logged
exp_xlogy.pl_ls <- map2(exp_var.comb$x, exp_var.comb$y, ~ {
  x_col <- .x
  y_col <- .y
  
  ggplot(exp_ss.df, aes_string(x = sprintf("log10(%s)", x_col), y = y_col)) +
        geom_path(aes(colour = Day, group = id), arrow = arrow(type = "closed", angle = 10, length = unit(0, "inches"))) +
        theme_classic() + 
        scale_color_viridis_c(option = "A", limits = c(3, 21)) +
        labs(color = "Days post-infection", x = paste(x_col, "log"))  +
        scale_y_continuous(labels = function(x) format(x, scientific = TRUE))
}
)

## y-axis logged
exp_xylog.pl_ls <- map2(exp_var.comb$x, exp_var.comb$y, ~ {
  x_col <- .x
  y_col <- .y
  
  ggplot(exp_ss.df, aes_string(x = x_col, y = sprintf("log10(%s)", y_col))) +
        geom_path(aes(colour = Day, group = id), arrow = arrow(type = "closed", angle = 10, length = unit(0, "inches"))) +
        theme_classic() + 
        scale_color_viridis_c(option = "A", limits = c(3, 21)) +
        labs(color = "Days post-infection", y = paste(y_col, "log"))   +
        scale_x_continuous(labels = label_scientific(digits = 1))
}
)

## both x and y axis is logged
exp_xlogylog.pl_ls <- map2(exp_var.comb$x, exp_var.comb$y, ~ {
  x_col <- .x
  y_col <- .y
  
  ggplot(exp_ss.df, aes_string(x = sprintf("log10(%s)", x_col), y = sprintf("log10(%s)", y_col))) +
        geom_path(aes(colour = Day, group = id), arrow = arrow(type = "closed", angle = 10, length = unit(0, "inches"))) +
        theme_classic() + 
        scale_color_viridis_c(option = "A", limits = c(3, 21)) +
        labs(color = "Days post-infection", x = paste(x_col, "log"), y = paste(y_col, "log")) 
}
)

## plot together
ggarrange(plotlist = c(exp_xy.pl_ls, exp_xlogy.pl_ls, exp_xylog.pl_ls, exp_xlogylog.pl_ls), 
          common.legend = T, align = "hv")
ggsave(here("code_repository/figures/exp_disease-curve.tiff"), units = "px", width = 2250, height = 1500, scale = 1.4, dpi=300,  bg = "white")

#=================================# # Simulated disease curve graph #=================================# ## Function to obtain dynamics data based on the dual cue input

get_dual_rn <- function(df){
  ## assign the two cues
  cue <- unique(df$cue)
  cue_b <- unique(df$cue_b)
  
  ## assign log status
  log <- ifelse(str_detect(unique(df$id), "log"), "log", "none")
  log_b <- ifelse(str_detect(unique(df$id_b), "log"), "log", "none")
  
  ## assign which cues are going to be logged
  if(log == "log" & log_b == "none"){logged_cue <- cue}
  if(log == "none" & log_b == "log"){logged_cue <- cue_b}
  if(log == "log" & log_b == "log"){logged_cue <- c(cue, cue_b)}
  if(log == "none" & log_b == "none"){logged_cue <- c()}

  ## keep variables that corresponds to the cue used
  ### for dataframes that does not involve combined variables such as I+Ig
  if(isTRUE(str_detect(cue, "\\+", negate = T)) & isTRUE(str_detect(cue_b, "\\+", negate = T))){
    df_f <- df %>% 
      filter(variable %in% c(cue, cue_b, "cr")) %>% 
      mutate(value = case_when(
        variable %in% logged_cue ~ log10(value),
        TRUE ~ value
      )) %>% ## log transform values only when they match with the logged cue list
      filter(value >= 0) ## filter out values <0, these happen due to stiffness of models but are not relevant
         
  } else{
    ### assign both cues to a list
    cue_ls <- c(cue, cue_b)
    ### pick the cue that has the "+" sign
    combined_cue <- cue_ls[grepl("\\+", cue_ls)]
    non_combined_cue <- cue_ls[!grepl("\\+", cue_ls)] ### this is the none combined cue
    ### unlist the cues
    cue_unlist <- unlist(str_split(combined_cue, "\\+"))
    
    ### get filtered dataset containing only non-combine cue
    df_f1 <- df %>% 
      filter(variable %in% c(non_combined_cue, "cr"))
    
    ### get filtered dataset containing combined cue. These will be summed up and bound back to the previous
    df_f2 <- df %>% 
      filter(variable %in% cue_unlist) %>% ## keep only variables that we will combine
      group_by(time) %>% ## for each time point, group the variables
      mutate(value = sum(value, na.rm = T),
             variable = combined_cue) %>% ## recalculate the value as sum of the values and reassign variable!
      distinct(time, .keep_all = T) ## note that because we are mutating we must dedeuplicate the records
    
    #### combine the two and log transform if necessary
    df_f <- rbind(df_f1, df_f2) %>% 
      mutate(value = ifelse(variable %in% logged_cue, log10(value), value)) %>% ## log transform values only when they match with the logged cue list
      filter(value >= 0) 
  }
  
  ## Convert dataframes wider such that the different variables have their own columns
  df_fp <- df_f %>% 
    mutate(variable_id = ifelse(variable == cue, paste0(variable, "_", log), paste0(variable, "_", log_b))) %>%  ### assign a unique variable id that could later be used to assign labels
    left_join(select(ez_label, id, long_label), by = c("variable_id" = "id")) %>% 
    mutate(long_label = ifelse(variable == "cr", "cr", long_label)) %>% ## manually add cr
    mutate(long_label = gsub(" ", "_", long_label)) %>%  ## convert spaces to _ for plotting
    pivot_wider(names_from = long_label, values_from = value, id_cols = c(time, id, id_b)) %>% 
    filter(time >= 1) %>% ## filter out day 0->1 because all cr = 0 before that
    arrange(time) ## this is needed to prevent geom_path from joining the first and last data point
  
  ## assign NAs (meaning no stuff is produced yet to 0)
  df_fp[is.na(df_fp)] <- 0

  return(df_fp)
}

Run function to get a curated dataset containing only relevant

## split dual dynamics dataframe into list grouped by the dual cues
dual_cue_dyn.ls <- dual_cue_dyn.df %>% group_split(id, id_b)

## run function across list
dual_cue_rn.ls <- mclapply(dual_cue_dyn.ls, get_dual_rn, mc.cores = 6)

## sanity checks that we are actually summing iRBCs. Rings out
max(dual_cue_rn.ls[[2]]$Total_iRBC)
max(dual_cue_rn.ls[[4]]$Asexual_iRBC)
max(dual_cue_rn.ls[[6]]$Sexual_iRBC)

max(dual_cue_rn.ls[[10]]$Total_iRBC)
max(dual_cue_rn.ls[[12]]$Asexual_iRBC)
max(dual_cue_rn.ls[[14]]$Sexual_iRBC)

plot

## list apply all dataframes
cue_cue_rn_pl.ls <- lapply(dual_cue_rn.ls,
       function(x){
          ## get names of columns used in the x and y axis
         axis_cols <- setdiff(names(x), c("time", "id", "id_b", "cr"))
         
         ## ggplot
         ggplot() +
           geom_path(data = x, aes_string(x = axis_cols[[1]], y = axis_cols[[2]], color = "cr"),
                     arrow = arrow(length = unit(c(rep(0, nrow(x) - 2), 0.25), "inches")),
                     size = 1.5) +
           geom_point(data = x %>% filter(time %% 1 == 0), 
                      aes_string(x = axis_cols[[1]], y = axis_cols[[2]]), size = 1.5, shape = 1) +
           theme_classic() +
           scale_color_viridis_c(limits = c(0, 1)) +
           labs(color = "Conversion rate", x = gsub("_", " ", axis_cols[[1]]), y = gsub("_", " ", axis_cols[[2]])) +
           scale_x_continuous(labels = label_scientific(digits = 2)) +
           scale_y_continuous(labels = label_scientific(digits = 2))
       })

## arrange together
cue_cue_rn.pl <- ggarrange(plotlist = cue_cue_rn_pl.ls, ncol = 5, nrow = 8, common.legend = T, align = "hv") 
ggsave(here("code_repository/figures/sim_disease-curve.tiff"), units = "px", width = 2250, height = 2500, scale = 2.2, dpi=300,  bg = "white")

#=================================# # Curating list of selected exo and simulated # disease curves (main figure) #=================================# # plot

# main figure
ggarrange(
   cue_cue_rn_pl.ls[[31]] +
    scale_x_continuous(labels = scales::number_format(accuracy = 0.1)) +
    scale_y_continuous(labels = scales::number_format(accuracy = 1)) +
    theme(legend.position = "none"), 
          
   exp_xlogylog.pl_ls[[1]] + theme(legend.position = "none"),

   cue_cue_rn_pl.ls[[35]] + 
     scale_y_continuous(labels = scales::number_format(accuracy = 1)) +
     theme(legend.position = "none",
           axis.text.x=element_text(size=6.5)), 
   
   exp_xylog.pl_ls[[1]] + 
     scale_y_continuous(labels = scales::number_format(accuracy = 1)) +
     theme(legend.position = "none",
           axis.text.x=element_text(size=6.5)),
   
   cue_cue_rn_pl.ls[[30]] + 
     scale_x_continuous(labels = scales::number_format(accuracy = 0.1)) +
     theme(legend.position = "none"), 
   
   exp_xlogy.pl_ls[[1]] + theme(legend.position = "none"), 
   
   cue_cue_rn_pl.ls[[15]] + 
     scale_x_continuous(labels = scales::number_format(accuracy = 0.1)) +
     theme(legend.position = "none"), 
   
   exp_xlogy.pl_ls[[2]] + theme(legend.position = "none"),
   
   align = "hv", ncol = 4, nrow = 2
)
ggsave(here("code_repository/figures/sim_exp_disease_curve_main.tiff"), units = "px", width = 2250, height = 1000, scale = 1.25, dpi=300,  bg = "white")


# get legend separately
ggarrange(
   cue_cue_rn_pl.ls[[31]] +
    scale_x_continuous(labels = scales::number_format(accuracy = 0.1)) +
    scale_y_continuous(labels = scales::number_format(accuracy = 1)) +
    theme(legend.position = "top"), 
          
   exp_xlogylog.pl_ls[[1]] + theme(legend.position = "top"))
ggsave(here("code_repository/figures/sim_exp_disease_curve_legend.tiff"), units = "px", width = 2250, height = 500, scale = 1.25, dpi=300,  bg = "white")

#=================================# # MC simulation of single cue and dual cue infection #=================================# #———— Impact of all parameter variation on fitness ————# ## Append all fitness data and sanity checks

length(mc_all_dc.ls)

[1] 20089

process data for plotting fitness

plot fitness variation

#———— Impact of individual parameter variation on fitness ————# ## combine all single parameter variation files

## list of file paths linked to the single parameter files
mc_single.ls <- list.files(path = here("code_repository/data/mc_single_fitness"), pattern = "*.csv", full.names = T)

## read and combine
mc_single_fitness.df <- do.call(rbind, mclapply(mc_single.ls, function(x) read.csv(x), mc.cores = 6))

# look at # of reps
mc_single_fitness.df %>% 
  group_by(id) %>% 
  tally()

## write
write_parquet(mc_single_fitness.df, here("code_repository/data/mc_single_fitness.parquet"))

## sanity check. iter = 1 is where all parameters are default. Should produce the same fitness values!
mc_single_fitness.df %>% filter(iter == 1)

process data for plotting

## note that for each iter across the "single" and "all" dataset, the parameter alteration is the same. Thus, for each data point at which all parameter are varied, there is a corresponding datapoint where only one parameter is varied. We can join these 2 dataset by iter and cue and log
mc_single_all_fitness.df <- mc_single_fitness.df %>% 
  left_join(select(mc_all_fitness.df, fitness_all = max_fitness,id, iter), by = c("id", "iter")) %>% 
  filter(iter %in% seq(0,1000,1)) ## only include the top 1000 records

## make the dataframe into a long format such that all fitness variations are in a single column
mc_single_fitness.long <- mc_single_all_fitness.df %>% 
  filter(iter != 1) %>% ## filter out iter = 1, which does not have variation
  left_join(select(mc_all_fitness_ref.df, fitness_ref = max_fitness, id),
            by = c("id")) %>% ## add in the deterministic fitness values
  select(id, max_fitness_rho, max_fitness_beta, max_fitness_psin, max_fitness_psiw, max_fitness_phin, max_fitness_phiw, iter, fitness_all, fitness_ref) %>% # keep only fitness and associated labels
  tidyr::pivot_longer(-c("id", "fitness_all", "iter", "fitness_ref")) %>% ## make long
  mutate(parameter = gsub("max_fitness_|fitness_", "", name)) ## isolate parameter being altered

## calculate degree deviation from deterministic values. note that rel_diff_single ranges from -1 to 1. -1 ->  one variable perturbation is acting in the opposite direction to the overall perturbation caused by randomizing all variables. 0 parameter variation contributes very little, 1 -> one variable contributes a lot
mc_single_fitness.long_p <- mc_single_fitness.long %>% 
  mutate(diff_single = value-fitness_ref, ## pertubation to fitness caused by single parameter variation
         diff_all = fitness_all-fitness_ref, ## pertubation to fintess caused by all parameter varying
         rel_diff_single = diff_single/diff_all ## normalized pertunation to fitness (single parameter)
         ) %>% 
  left_join(ez_label, by = c("id"))

## calculate summary statistics. this includes median, credible interval (contains 89% data points calculated via Highest Density Interval, which is better for skewed data)
mc_single_fitness.long_p %>% filter(id == "R_log-I+Ig_log")

mc_single_fitness.sum <- mc_single_fitness.long_p %>% 
  group_by(id, parameter, short_label) %>% 
  summarise(ci_lower = ci(rel_diff_single, method = "HDI", ci = 0.89)[[2]],
            ci_higher = ci(rel_diff_single, method = "HDI", ci = 0.89)[[3]],
            quantile_low = quantile(rel_diff_single, 0.025),
            quantile_high = quantile(rel_diff_single, 0.975),
            median = median(rel_diff_single),
            mean = mean(rel_diff_single)) %>% 
  mutate(parameter_label = case_when( ## recode parameter values
    parameter == "rho" ~ "RBC replenishment (ρ)",
    parameter == "phin" ~ "Half-life indis (ϕn)",
    parameter == "phiw" ~ "Half-life targeted (ϕw)",
    parameter == "psin" ~ "Activation indis (ψn)",
    parameter == "psiw" ~ "Activation targeted (ψw)",
    parameter == "beta" ~ "Burst size (β)",
  ))

`summarise()` has grouped output by 'id', 'parameter'. You can override using the `.groups`
argument.

## for violin plots, what we can do is plot out only the 89% credible interval so the graph is easier to interpret
mc_single_fitness.long_p_f <- mc_single_fitness.long_p %>% 
  left_join(select(mc_single_fitness.sum, short_label, parameter, ci_lower, ci_higher, parameter_label), by = c("short_label", "parameter")) %>% 
  filter(rel_diff_single >= ci_lower & rel_diff_single < ci_higher)

Adding missing grouping variables: `id`

## arrange ordering of cues and parameters
mc_single_fitness.long_p_f$short_label <- factor(mc_single_fitness.long_p_f$short_label, c(
  "R & I log", "R log & I log",
  "R & Total I log","R log & Total I log",
  "R", "R log",
  "I", "I log",
  "Ig", "Ig log", 
  "Total I", "Total I log",
  "G", "G log"))

mc_single_fitness.long_p_f$parameter_label <- factor(mc_single_fitness.long_p_f$parameter_label,
                                                     c("Burst size (β)",
                                                       "RBC replenishment (ρ)",
                                                       "Half-life indis (ϕn)",
                                                       "Half-life targeted (ϕw)",
                                                       "Activation indis (ψn)",
                                                       "Activation targeted (ψw)"))

plotting 89% credible interval. By visual inspection of the distribution, ci represented the distribution (more honestly) than quantile, even when quantile seems to display larger differences of logging cues.

#——— arrange plots together ———#

ggarrange(mc_all_fitness.pl, mc_partition.pl, align = "h", widths = c(1.3, 2), labels = c("A", "B"))

Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <ce>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <b2>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <81>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <ce>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <b2>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <81>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <ce>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <b2>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <81>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <ce>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <b2>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <81>
Warning: Graphs cannot be horizontally aligned unless the axis parameter is set. Placing graphs unaligned.

ggarrange(mc_all_fitness.pl, mc_partition.pl, align = "h", widths = c(1.3, 2), labels = c("A", "B"))

Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <ce>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <b2>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <81>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <ce>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <b2>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <81>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <ce>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <b2>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <81>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation indis (ψn)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Activation targeted (ψw)' in 'mbcsToSbcs': dot substituted for <88>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <ce>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Burst size (β)' in 'mbcsToSbcs': dot substituted for <b2>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life indis (ϕn)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'Half-life targeted (ϕw)' in 'mbcsToSbcs': dot substituted for <95>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <cf>
Warning in grid.Call(C_textBounds, as.graphicsAnnot(x$label), x$x, x$y,  :
  conversion failure on 'RBC replenishment (ρ)' in 'mbcsToSbcs': dot substituted for <81>
Warning: Graphs cannot be horizontally aligned unless the axis parameter is set. Placing graphs unaligned.

ggsave(units = "px", dpi = 300, width = 2250, height = 1500, filename = here("code_repository/figures/mc_fitness_partition.tiff"), bg = "white", scale = 1.2)

#==========================================# # Supplementary figure on MC posterior parameter distribution #==========================================# ## Process data

## manually make dataframe containing the parameter values used in the deterministic model
par_det.df <- data.frame(
  parameter = c("rho", "phi_N1", "phi_N2", "iota_N1", "iota_N2", "burst"),
  deterministic = c(2.627156e-01, 3.520591e-02, 5.508420e+02, 1.669234e+01, 8.431785e-01, 5.721000e+00 )
)

## make into long format
posterior.long <- posterior.df %>% 
  filter(id %in% seq(0,1000,1)) %>% 
  tidyr::pivot_longer(-id, names_to = "parameter") %>% 
  left_join(par_det.df, by = "parameter") %>% ## add in the deterministic parameter values
  mutate(label = case_when(
    parameter == "rho" ~ "RBC replenishment (ρ)",
    parameter == "phi_N1" ~ "Half-life indis (ϕn)",
    parameter == "phi_N2" ~ "Half-life targeted (ϕw)",
    parameter == "iota_N1" ~ "Activation indis (ψn)",
    parameter == "iota_N2" ~ "Activation targeted (ψw)",
    parameter == "burst" ~ "Burst size (β)"
  )) ## rename paramter values

plot

## portion of parameter values that does not need log-transforming
posterior_1.pl <- ggplot(posterior.long %>% filter(!parameter %in% c("phi_N1", "phi_N2", "iota_N1"))) +
  geom_density(aes(x = value), fill = "grey") +
  geom_vline(aes(xintercept = deterministic), linetype = "dashed") +
  facet_wrap(~label, scales = "free") +
  labs(x = "", y = "Density") +
  theme_bw() +
  theme(panel.grid.major = element_blank(),
        panel.grid.minor = element_blank())

## Plots where the x-axis should be log-transformed so it is easier to read
posterior_2.pl <- ggplot(posterior.long %>% filter(parameter %in% c("phi_N1", "phi_N2", "iota_N1"))) +
  geom_density(aes(x = value), fill = "grey") +
  geom_vline(aes(xintercept = deterministic), linetype = "dashed") +
  facet_wrap(~label, scales = "free") +
  labs(x = "Value", y = "Density") +
  scale_x_continuous(trans = "log10") +
  theme_bw() +
  theme(panel.grid.major = element_blank(),
        panel.grid.minor = element_blank())

## plot together
ggarrange(posterior_1.pl, posterior_2.pl, ncol = 1, align = "hv")
  
## save
ggsave(units = "px", dpi = 300, width = 2000, height = 1300, filename = here("code_repository/figures/posterior.tiff"), bg = "white", scale = 1)

#==========================================# # Rank plot of parasite fitness with only one parameter varying #==========================================# ## Process data

## get median fitness values (normalized)
mc_single_fitness.sum2 <- mc_single_fitness.long2 %>% 
  group_by(short_label, id, parameter_label, parameter) %>% 
  summarize(median = median(fitness_norm),
            mean = mean(fitness_norm),
            geo_mean = exp(mean(log(fitness_norm))),
            fitness_det_norm = unique(fitness_det_norm)) %>% 
  left_join(select(mc_all_fitness_sum.df, short_label, geo_mean_all = geom_mean), by = "short_label") ## get geometric mean of when all parameter are varied

`summarise()` has grouped output by 'short_label', 'id', 'parameter_label'. You can override
using the `.groups` argument.

plot

note that it is quite a hassel to reorder cues when facetting. Hence, I will just plot out all 6 plots individually

# split database by parameter
mc_single_fitness_long2.ls <- split(mc_single_fitness.long2, mc_single_fitness.long2$parameter_label)
mc_single_fitness_sum2.ls <- split(mc_single_fitness.sum2, mc_single_fitness.sum2$parameter_label)

# plot out individual ggplot 
mc_single_plt.ls <- list()
for(i in seq(1,6,1)){
 mc_single_plt.ls[[i]] <- ggplot() +
  geom_violin(data = mc_single_fitness_long2.ls[[i]],
              aes(x = fct_reorder(short_label, geo_mean, .desc = T), y = fitness_norm), 
              fill = "grey", trim = T, color = "grey") +
  geom_point(data =  mc_single_fitness_sum2.ls[[i]],
             aes(x = short_label, y = mean, shape = "Mean", color = "Mean"), size = 2) +
  geom_point(data =  mc_single_fitness_sum2.ls[[i]],
             aes(x = short_label, y = geo_mean, shape = "Geometric mean\n(single parameter)", color = "Geometric mean\n(single parameter)"), size = 2) +
  geom_point(data =  mc_single_fitness_sum2.ls[[i]],
             aes(x = short_label, y = fitness_det_norm, shape = "Deterministic", color = "Deterministic"), size =2) +
   geom_point(data =  mc_single_fitness_sum2.ls[[i]],
             aes(x = short_label, y = geo_mean_all, shape = "Geometric mean\n(all parameters)", color = "Geometric mean\n(all parameters)"), size =2) +
  labs(x = "Cue(s)", y = "Normalized fitness", shape = "Legend", color = "Legend",
       subtitle = unique(mc_single_fitness_sum2.ls[[i]]$parameter_label)) +
  scale_color_manual(values = c("black", "#785EF0","#785EF0", "#FFB000")) +
   scale_shape_manual(values = c(16, 2, 17, 15))+
   ylim(0, 1.2) +
  theme_classic() +
  theme(axis.text.x=element_text(angle=45,hjust=1))
         
}

## arrange together
ggarrange(plotlist = mc_single_plt.ls, common.legend = T, ncol = 3, nrow = 2, align = "hv")

ggsave(units = "px", dpi = 300, width = 2500, height = 2000, filename = here("code_repository/figures/mc_single_fitness.tiff"), bg = "white", scale = 1)

#==================================# # Understanding the mechanism behind robustness #==================================# #——–Calculating deviations between cr and fitness———-# # Process single parameter dynamics data

# get list of files
mc_single_dyn.ls <- list.files(here("code_repository/data/mc_single_dyn"), pattern = "*.parquet", full.names = T)

# read in all of the files, filtering only for conversion rate
mc_single_dyn_cr.ls <- mclapply(mc_single_dyn.ls, function(x){
  df <- read_parquet(x)
  
  ## filter to retain only cr
  df_f <- df %>% filter(variable == "cr")
  return(df_f)
}, mc.cores = 6)

# combine
mc_single_dyn_cr.df <- do.call(rbind, mc_single_dyn_cr.ls)

# write
write_parquet(mc_single_dyn_cr.df, here("code_repository/data/mc_single_dyn_cr.parquet"))
mc_single_dyn_cr.df <- read_parquet(here("code_repository/data/mc_single_dyn_cr.parquet"))

# check # of records
mc_single_dyn_cr.df %>% group_by(id) %>% tally()

Process deterministic conversion rate time series dynamic

# single cue dynamics (conversion rate only)
si_cr.df <- si_dyn.df %>%
  filter(variable == "cr") %>%  ## get corresponding time steps (0.01) and cr only
  select(id, time, cr_det = value)

# dual cue dynamics (conversion rate only)
dual_cr.df <- dual_cue_dyn.df %>% 
  filter(variable == "cr") %>% 
  mutate(id = paste0(id, "-", id_b)) %>% 
  select(id, time, cr_det = value)

Calculate deviation in cr

mc_single_dyn_cr.sum

Error: object 'mc_single_dyn_cr.sum' not found

calculate loss of fitness due to variation

mc_single_dyn_cr.sum_fitness <- mc_single_fitness.sum %>% 
  mutate(geo_mean_diff = geo_mean-fitness_det_norm) %>% 
  left_join(mc_single_dyn_cr.sum, by = c("id", "parameter"))

Error in mutate(., geo_mean_diff = geo_mean - fitness_det_norm) : 
  object 'mc_single_fitness.sum' not found

isolate examples of robust and non-robust cues

## robust cue (I log)
mc_single_dyn_cr_join.df_p_robust <- mc_single_dyn_cr_join.df_p %>% 
  filter(id == "I_log" & parameter %in% c("beta", "psin") & row_number() %% 10 == 0) %>% 
  mutate(parameter_label = case_when(
    parameter == "psin" ~ "Activation indis (ψn)",
    parameter == "beta" ~ "Burst size (β)"
  ))

Error in filter(., id == "I_log" & parameter %in% c("beta", "psin") &  : 
  object 'mc_single_dyn_cr_join.df_p' not found

plot cr time series

mc_single_cr_dyn.plt1 <- ggplot(mc_single_dyn_cr_join.df_p_robust) +
  geom_line(aes(x = time, y = value, group = iter), alpha = 0.01) +
  geom_line(aes(x = time, y = cr_det, group = iter), alpha = 1, color = "#785EF0") +
  facet_wrap(~parameter_label) +
  ylim(0, 1) +
  labs(x = "", y = "Conversion rate") +
  theme_bw() +
  theme(panel.grid.major = element_blank(),
        panel.grid.minor = element_blank(),
        axis.title.x = element_blank())

mc_single_cr_dyn.plt2 <- ggplot(mc_single_dyn_cr_join.df_p_notrobust) +
  geom_line(aes(x = time, y = value, group = iter), alpha = 0.01) +
  geom_line(aes(x = time, y = cr_det, group = iter), alpha = 1, color = "#785EF0") +
  facet_wrap(~parameter_label) +
  ylim(0, 1) +
  labs(x = "Time (days)", y = "Conversion rate") +
  theme_bw() +
  theme(panel.grid.major = element_blank(),
        panel.grid.minor = element_blank())

plot relationship

# relationship between fitness vs robistness
ggplot(mc_single_dyn_cr.sum_fitness, aes(x = fitness_det_norm, y = geo_mean_diff, color = fitness_det_norm)) +
  geom_point(size = 2.5, color = "black", shape = 1) +
  geom_point(size = 2, alpha=0.8) +
  facet_wrap(~parameter_label, scales = "free") +
  scale_color_viridis_c() +
  labs(x = "Deterministic model fitness", y = "Normalized fitness difference\n(Single-Deterministic)", color = "Deterministic\nmodel fitness") +
  theme_bw() +
  theme(panel.grid.major = element_blank(),
        panel.grid.minor = element_blank())

# relationship between conversion rate difference and difference in fitness 
ggplot(mc_single_dyn_cr.sum_fitness, aes(x = median_cr_diff, geo_mean_diff, color = fitness_det_norm)) +
  geom_point(size = 2.5, color = "black", shape = 1) +
  geom_point(size = 2, alpha=0.8) +
  facet_wrap(~parameter_label) +
  scale_color_viridis_c() +
  ylim(NA, 0.02) +
  labs(x = "Median conversion rate difference", y = "Normalized fitness difference\n(Single-Deterministic)", color = "Deterministic\nmodel fitness") +
  theme_bw() +
  theme(panel.grid.major = element_blank(),
        panel.grid.minor = element_blank(),
        legend.position = "bottom")

ggsave(here("code_repository/figures/mc_single_cr_rel_int.tiff"), units = "px", dpi = 300, width = 2550, height = 1200, bg = "white", scale = 1)

# internal code to get positions of I log and R and I+Ig log
ggplot(mc_single_dyn_cr.sum_fitness, aes(x = median_cr_diff, geo_mean_diff, color = fitness_det_norm)) +
  geom_point(size = 2.5, color = "black", shape = 1) +
  geom_point(size = 2, alpha=0.8) +
  geom_text(data = mc_single_dyn_cr.sum_fitness %>% filter(id %in% c("I_log", "R_none-I+Ig_log")), aes(x = median_cr_diff, y =geo_mean_diff, label = id)) +
  facet_wrap(~parameter_label) +
  scale_color_viridis_c() +
  ylim(NA, 0.02) +
  labs(x = "Median conversion rate difference", y = "Normalized fitness difference\n(Single-Deterministic)", color = "Deterministic\nmodel fitness") +
  theme_bw() +
  theme(panel.grid.major = element_blank(),
        panel.grid.minor = element_blank(),
        legend.position = "bottom")

plot together

# conversion rate dynamic
ggarrange(mc_single_cr_dyn.plt1, mc_single_cr_dyn.plt2, nrow = 2, align = "v", labels = c("B", "C"))
ggsave(here("code_repository/figures/mc_single_cr_dyn_int.tiff"), units = "px", dpi = 300, width = 2550*(2/3), height = 1000, bg = "white", scale = 1)

#=====================================# # Impact of cue perception on virulence #====================================# #——— Divid dynamics data into high and low performing —————# # Single cue

Dual cue

# classify top 4 performing dual cues as "high performing"
top_4_dual_cue <- dual_cue_f_final.df %>% 
  mutate(label_alt = paste(label, "&" , label_b)) %>% 
  slice_max(n = 4, order_by = fitness)

# get wide format dataframe. Here, we are interested in the RBC and total iRBC count
dual_dc.df <- dual_cue_dyn_30.df %>% 
  mutate(label_alt = paste(label, "&" , label_b)) %>% ## get new label
  filter(variable == "I" | variable == "Ig" | variable == "R") %>% ## get desired variables
  tidyr::pivot_wider(names_from = variable, values_from = value, id_cols = c(time, label_alt)) %>%
  mutate(total = I+Ig)

# split into top and poor-performing cues
dual_dc.high <- dual_dc.df %>% filter(label_alt %in% top_4_dual_cue$label_alt)

# reorder cues by descending fitness
dual_dc.high$label_alt <- factor(dual_dc.high$label_alt, top_4_dual_cue$label_alt)

#————Get reference dynamics—————# # the ideal dynamic (time as cue, df = 9)

time_high.dyn <- chabaudi_si_clean_high(
  parameters_cr = c(9.154314,  -7.570829, -22.506638 ,  3.382405 ,-13.453519 ,-17.011485  , 3.678181, -12.851895 ,-26.115158),
  immunity = "tsukushi",
  parameters = parameters_tsukushi,
  time_range = seq(0, 30, by = 1e-3),
  cue_range =  seq(0, 20, by = 1e-3),
  cue = "t",
  solver = "vode",
  dyn = T)

[1] "Time is chosen as cue. Cue_range must equal to time_range"

#————-Plot disease curves—————–# # Single cue

dual cue

#———area of curve vs fitness—————# # function to calculate area within curve

get_dc_area <- function(df){
  x <- df$total
  y <- df$R
  chull(x,y)->i
  return(areapl(cbind(x[i],y[i])))
}

single cue area

# split df
si_dc.ls <- split(si_dc.df, si_dc.df$id)

# get area
si_dc.area <- cbind.data.frame(area = as.numeric(lapply(si_dc.ls, get_dc_area)), id = names(lapply(si_dc.ls, get_dc_area)))

# join with fitness
si_opt_area.df <- si_opt.df %>% 
  filter(cue != "t") %>% 
  left_join(si_dc.area, by = "id") %>% 
  mutate(fitness_norm = fitness_20/9.883602) ## normalize fitness (use fitness obtained using time df=9 given that we are plotting dual cue and single on the same graph!)

# sanity check area. The area should be on the order if we assume a rectangle!
si_dc.df %>% 
  group_by(id) %>% 
  summarise(R_diff = max(R)-min(R),
            total_diff = max(total)-min(total),
            product = R_diff*total_diff)

dual cue

# split
dual_dc.ls <- split(dual_dc.df, dual_dc.df$label_alt)

# get area
dual_dc.area <- cbind.data.frame(area = as.numeric(lapply(dual_dc.ls, get_dc_area)), label_alt = names(lapply(dual_dc.ls, get_dc_area)))

# join with fitness
dual_cue_f_final_area.df <- dual_cue_f_final.df %>% 
  mutate(label_alt = gsub("I\\+Ig", "Total I", paste(label, "&" , label_b))) %>% 
  left_join(dual_dc.area, by = c("label_alt")) %>% 
  mutate(fitness_norm = fitness/9.883602) ## normalize fitness (use fitness obtained using time df=9 given that we are plotting dual cue and single on the same graph!)

get area for ideal and static cr

# time
time_high.area <- get_dc_area(time_high.vir)

fit GLM

Note that static and time based cue is not included in the model!

# fit lm
si_lm <- lm(fitness_norm ~ area, data = si_opt_area.df)
dual_lm <- lm(fitness_norm ~ area, data = dual_cue_f_final_area.df)

# get prediction with 95% CI
si_lm.ci = predict(si_lm, interval = "confidence") %>% cbind.data.frame(area = si_opt_area.df$area)
dual_lm.ci = predict(dual_lm, interval = "confidence") %>% cbind.data.frame(area = dual_cue_f_final_area.df$area)

# look at R^2
summary(si_lm)$r.squared ## 0.1765248

[1] 0.1765248

summary(dual_lm)$r.squared ## 0.1053591

[1] 0.1053591

plot correlation

ggplot() +
  geom_point(data = dual_cue_f_final_area.df, aes(x = area, y = fitness_norm, color = "Dual cue", shape = "Dual cue"), size = 3, alpha = 0.7) +
  geom_point(aes(x = time_high.area, y = max(time_high.dyn %>% filter(variable == "tau_cum" & time == 20) %>% pull(value))/9.883602, color = "Time", shape = "Time"), size = 3) +
  geom_line(data = dual_lm.ci, aes(x = area, fit)) +
  geom_ribbon(data = dual_lm.ci, aes(x = area, ymin = lwr, ymax = upr), alpha = .15) +
  annotate(geom = "text", label = "R^2=0.11", x = 1.6*(10^11), y = 0.76) +
  annotate(geom = "text", label = "Time", x = 2.7*(10^11), y = 0.98) +
  labs(x = "Area", y = "Normalized fitness", shape = "Cue category", color = "Cue category") +
  scale_color_manual(values = c(blue, "black")) +
  xlim(min(si_opt_area.df$area), max(dual_cue_f_final_area.df$area)) +
  theme_classic() +
  theme(legend.position = "none")

Warning: Removed 2 rows containing missing values or values outside the scale range (`geom_point()`).
Warning: Removed 2 rows containing missing values or values outside the scale range (`geom_line()`).

#———assemble figure————#

#=============================# # Validation of optimization #=============================# #—— process input data ——# # Process data

Plot